226 research outputs found
Self-stabilising Byzantine Clock Synchronisation is Almost as Easy as Consensus
We give fault-tolerant algorithms for establishing synchrony in distributed
systems in which each of the nodes has its own clock. Our algorithms
operate in a very strong fault model: we require self-stabilisation, i.e., the
initial state of the system may be arbitrary, and there can be up to
ongoing Byzantine faults, i.e., nodes that deviate from the protocol in an
arbitrary manner. Furthermore, we assume that the local clocks of the nodes may
progress at different speeds (clock drift) and communication has bounded delay.
In this model, we study the pulse synchronisation problem, where the task is to
guarantee that eventually all correct nodes generate well-separated local pulse
events (i.e., unlabelled logical clock ticks) in a synchronised manner.
Compared to prior work, we achieve exponential improvements in stabilisation
time and the number of communicated bits, and give the first sublinear-time
algorithm for the problem:
- In the deterministic setting, the state-of-the-art solutions stabilise in
time and have each node broadcast bits per time
unit. We exponentially reduce the number of bits broadcasted per time unit to
while retaining the same stabilisation time.
- In the randomised setting, the state-of-the-art solutions stabilise in time
and have each node broadcast bits per time unit. We
exponentially reduce the stabilisation time to while each node
broadcasts bits per time unit.
These results are obtained by means of a recursive approach reducing the
above task of self-stabilising pulse synchronisation in the bounded-delay model
to non-self-stabilising binary consensus in the synchronous model. In general,
our approach introduces at most logarithmic overheads in terms of stabilisation
time and broadcasted bits over the underlying consensus routine.Comment: 54 pages. To appear in JACM, preliminary version of this work has
appeared in DISC 201
Byzantine Approximate Agreement on Graphs
Consider a distributed system with n processors out of which f can be Byzantine faulty. In the approximate agreement task, each processor i receives an input value x_i and has to decide on an output value y_i such that
1) the output values are in the convex hull of the non-faulty processors\u27 input values,
2) the output values are within distance d of each other.
Classically, the values are assumed to be from an m-dimensional Euclidean space, where m >= 1.
In this work, we study the task in a discrete setting, where input values with some structure expressible as a graph. Namely, the input values are vertices of a finite graph G and the goal is to output vertices that are within distance d of each other in G, but still remain in the graph-induced convex hull of the input values. For d=0, the task reduces to consensus and cannot be solved with a deterministic algorithm in an asynchronous system even with a single crash fault. For any d >= 1, we show that the task is solvable in asynchronous systems when G is chordal and n > (omega+1)f, where omega is the clique number of G. In addition, we give the first Byzantine-tolerant algorithm for a variant of lattice agreement. For synchronous systems, we show tight resilience bounds for the exact variants of these and related tasks over a large class of combinatorial structures
Towards Optimal Synchronous Counting
Consider a complete communication network of nodes, where the nodes
receive a common clock pulse. We study the synchronous -counting problem:
given any starting state and up to faulty nodes with arbitrary behaviour,
the task is to eventually have all correct nodes counting modulo in
agreement. Thus, we are considering algorithms that are self-stabilizing
despite Byzantine failures. In this work, we give new algorithms for the
synchronous counting problem that (1) are deterministic, (2) have linear
stabilisation time in , (3) use a small number of states, and (4) achieve
almost-optimal resilience. Prior algorithms either resort to randomisation, use
a large number of states, or have poor resilience. In particular, we achieve an
exponential improvement in the space complexity of deterministic algorithms,
while still achieving linear stabilisation time and almost-linear resilience.Comment: 17 pages, 2 figure
Large Cuts with Local Algorithms on Triangle-Free Graphs
We study the problem of finding large cuts in -regular triangle-free
graphs. In prior work, Shearer (1992) gives a randomised algorithm that finds a
cut of expected size , where is the number of
edges. We give a simpler algorithm that does much better: it finds a cut of
expected size . As a corollary, this shows that in
any -regular triangle-free graph there exists a cut of at least this size.
Our algorithm can be interpreted as a very efficient randomised distributed
algorithm: each node needs to produce only one random bit, and the algorithm
runs in one synchronous communication round. This work is also a case study of
applying computational techniques in the design of distributed algorithms: our
algorithm was designed by a computer program that searched for optimal
algorithms for small values of .Comment: 1+17 pages, 8 figure
Near-optimal self-stabilising counting and firing squads
Consider a fully-connected synchronous distributed system consisting of n nodes, where up to f nodes may be faulty and every node starts in an arbitrary initial state. In the synchronous C-counting problem, all nodes need to eventually agree on a counter that is increased by one modulo C in each round for given C>1. In the self-stabilising firing squad problem, the task is to eventually guarantee that all non-faulty nodes have simultaneous responses to external inputs: if a subset of the correct nodes receive an external “go” signal as input, then all correct nodes should agree on a round (in the not-too-distant future) in which to jointly output a “fire” signal. Moreover, no node should generate a “fire” signal without some correct node having previously received a “go” signal as input. We present a framework reducing both tasks to binary consensus at very small cost. For example, we obtain a deterministic algorithm for self-stabilising Byzantine firing squads with optimal resilience f<n/3, asymptotically optimal stabilisation and response time O(f), and message size O(log f). As our framework does not restrict the type of consensus routines used, we also obtain efficient randomised solutions
Local algorithms in (weakly) coloured graphs
A local algorithm is a distributed algorithm that completes after a constant
number of synchronous communication rounds. We present local approximation
algorithms for the minimum dominating set problem and the maximum matching
problem in 2-coloured and weakly 2-coloured graphs. In a weakly 2-coloured
graph, both problems admit a local algorithm with the approximation factor
, where is the maximum degree of the graph. We also give
a matching lower bound proving that there is no local algorithm with a better
approximation factor for either of these problems. Furthermore, we show that
the stronger assumption of a 2-colouring does not help in the case of the
dominating set problem, but there is a local approximation scheme for the
maximum matching problem in 2-coloured graphs.Comment: 14 pages, 3 figure
Deterministic Subgraph Detection in Broadcast CONGEST
We present simple deterministic algorithms for subgraph finding and enumeration in the broadcast CONGEST model of distributed computation:
- For any constant k, detecting k-paths and trees on k nodes can be done in O(1) rounds.
- For any constant k, detecting k-cycles and pseudotrees on k nodes can be done in O(n)
rounds.
- On d-degenerate graphs, cliques and 4-cycles can be enumerated in O(d + log n) rounds, and
5-cycles in O(d2 + log n) rounds.
In many cases, these bounds are tight up to logarithmic factors. Moreover, we show that the algorithms for d-degenerate graphs can be improved to O(d/logn) and O(d2/logn), respect- ively, in the supported CONGEST model, which can be seen as an intermediate model between CONGEST and the congested clique
Fast Graphical Population Protocols
Let be a graph on nodes. In the stochastic population protocol model,
a collection of indistinguishable, resource-limited nodes collectively
solve tasks via pairwise interactions. In each interaction, two randomly chosen
neighbors first read each other's states, and then update their local states. A
rich line of research has established tight upper and lower bounds on the
complexity of fundamental tasks, such as majority and leader election, in this
model, when is a clique. Specifically, in the clique, these tasks can be
solved fast, i.e., in pairwise interactions, with
high probability, using at most states per node.
In this work, we consider the more general setting where is an arbitrary
graph, and present a technique for simulating protocols designed for
fully-connected networks in any connected regular graph. Our main result is a
simulation that is efficient on many interesting graph families: roughly, the
simulation overhead is polylogarithmic in the number of nodes, and quadratic in
the conductance of the graph. As a sample application, we show that, in any
regular graph with conductance , both leader election and exact majority
can be solved in pairwise
interactions, with high probability, using at most states per node. This shows that there are fast and
space-efficient population protocols for leader election and exact majority on
graphs with good expansion properties. We believe our results will prove
generally useful, as they allow efficient technology transfer between the
well-mixed (clique) case, and the under-explored spatial setting.Comment: 47 pages, 5 figure
EFFICIENT COUNTING WITH OPTIMAL RESILIENCE
Consider a complete communication network of n nodes, where the nodes receive a common clock pulse. We study the synchronous c-counting problem: given any starting state and up to f faulty nodes with arbitrary behavior, the task is to eventually have all correct nodes labeling the pulses with increasing values modulo c in agreement. Thus, we are considering algorithms that are self-stabilizing despite Byzantine failures. In this work, we give new algorithms for the synchronous counting problem that (1) are deterministic, (2) have optimal resilience, (3) have a linear stabilization time in f (asymptotically optimal), (4) use a small number of states, and, consequently, (5) communicate a small number of bits per round. Prior algorithms either resort to randomization, use a large number of states and need high communication bandwidth, or have suboptimal resilience. In particular, we achieve an exponential improvement in both state complexity and message size for deterministic algorithms. Moreover, we present two complementary approaches for reducing the number of bits communicated during and after stabilization.Peer reviewe
- …